#pragma once

#include <iostream>
#include <vector>
#include <cassert>
#include <algorithm>
#include <cstring>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <fcntl.h>
#include <functional>
#include <sys/epoll.h>
#include <unordered_map>
#include <mutex>
#include <thread>
#include <sys/eventfd.h>
#include <memory>
#include <cstdint>
#include <typeinfo>
#include <sys/timerfd.h>
#include <condition_variable>
#include <pthread.h>
#include <signal.h>

#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL DBG

#define LOG(level, format, ...)                                                                                        \
    do                                                                                                                 \
    {                                                                                                                  \
        if (level < LOG_LEVEL)                                                                                         \
            break;                                                                                                     \
        time_t t = time(NULL);                                                                                         \
        struct tm *ltm = localtime(&t);                                                                                \
        char tmp[32] = {0};                                                                                            \
        strftime(tmp, 31, "%H:%M:%S", ltm);                                                                            \
        fprintf(stdout, "[%p %s %s:%d] " format "\n", (void *)pthread_self(), tmp, __FILE__, __LINE__, ##__VA_ARGS__); \
    } while (0)

#define ILOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DLOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ELOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)

#define BUFFER_DEFAULT_SIZE 1024

class Buffer
{
private:
    std::vector<char> _buffer; // 使用vector连续空间存储数据
    uint64_t _writer_index;    // 写位置的相对偏移
    uint64_t _reader_index;    // 读位置的相对偏移
public:
    Buffer() : _writer_index(0), _reader_index(0), _buffer(BUFFER_DEFAULT_SIZE) {}
    char *Begin()
    {
        return &*_buffer.begin();
    }
    // 获取当前写位置的地址
    char *GetWriterPos()
    {
        // 起始地址 + 写偏移
        return Begin() + _writer_index;
    }

    // 获取当前读位置的地址
    char *GetReaderPos()
    {
        // 起始地址 + 读偏移
        return Begin() + _reader_index;
    }

    // 获取后沿空间的大小(Write位置之后还有多少空间)
    uint64_t GetTailSize()
    {
        // 总的空间大小 - 写位置的偏移量
        return _buffer.size() - _writer_index;
    }

    // 获取前沿空间大小(Read位置之前还有多少空间)
    uint64_t GetHeadSize()
    {
        return _reader_index;
    }

    // 获取可读数据的大小
    uint64_t ReadAbleSize()
    {
        // 写偏移 - 读偏移
        return _writer_index - _reader_index;
    }

    // 将读偏移向后移动指定位置
    void ReadMoveOffset(uint64_t len)
    {
        if (len == 0)
            return;
        // 小于可读空间大小
        assert(len <= ReadAbleSize());
        _reader_index += len;
    }

    // 将写偏移向后移动指定位置
    void WriteMoveOffset(uint64_t len)
    {
        // 小于后沿空间大小
        assert(len <= GetTailSize());
        _writer_index += len;
    }

    // 确保可写空间足够（剩余空间足够就移动数据，不足则在后沿空间上进行扩容）
    void EnsureWriterSpace(uint64_t len)
    {
        // 可写空间足够，放入数据在后沿，只需要判断后沿空间即可
        if (len <= GetTailSize())
        {
            return;
        }
        // 剩余空间足够
        if (len <= GetHeadSize() + GetTailSize())
        {
            // 将数据拷贝到buffer最前端即可
            uint64_t rsz = ReadAbleSize();                            // 保存原来的可读空间大小
            std::copy(GetReaderPos(), GetReaderPos() + rsz, Begin()); // 直接将数据拷贝到起始位置
            _reader_index = 0;
            _writer_index = rsz;
        }
        else
        {
            // 空间不够，直接对后沿空间进行扩容
            _buffer.resize(_writer_index + len);
        }
    }

    // 向buffer中写void类型数据
    void Write(const void *data, uint64_t len)
    {
        if (len == 0)
        {
            return;
        }
        // 1、确保有足够大的空间
        EnsureWriterSpace(len);
        // 2、将数据拷贝到buffer中
        const char *d = (const char *)data;
        std::copy(d, d + len, GetWriterPos());
    }

    // 并将writer偏移量移动到数据位置
    void WriterAndPush(const void *data, uint64_t len)
    {
        Write(data, len);
        WriteMoveOffset(len);
    }

    // 向buffer中写入string类型的数据
    void WriteString(const std::string &str)
    {
        Write(str.c_str(), str.size());
    }

    void WriteStringAndPush(const std::string &str)
    {
        WriteString(str);
        WriteMoveOffset(str.size());
    }

    // 向buffer中写入buffer类型的数据  不能加const，都是非const成员函数
    void WriteBuffer(Buffer &buffer)
    {
        Write(buffer.GetReaderPos(), buffer.ReadAbleSize());
    }

    void WriteBufferAndPush(Buffer &buffer)
    {
        WriteBuffer(buffer);
        WriteMoveOffset(buffer.ReadAbleSize());
    }

    // 读取buffer中的数据
    void Read(void *buf, uint64_t len)
    {
        // 要求读取的数据大小小于可读数据大小
        assert(len <= ReadAbleSize());
        std::copy(GetReaderPos(), GetReaderPos() + len, (char *)buf);
    }

    // 并将read的偏移位置向后移动
    void ReadAndPop(void *buf, uint64_t len)
    {
        Read(buf, len);
        ReadMoveOffset(len);
    }

    // 将读取到的数据作为string类型返回
    std::string ReadAsString(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str;
        str.resize(len);
        Read(&str[0], len); // 不能使用c_str() 接口，返回类型是const的
        return str;
    }

    std::string ReadAsStringAndPop(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str = ReadAsString(len);
        ReadMoveOffset(len);
        return str;
    }

    // 获取回车换行的位置在每一行中
    char *FindCRLF()
    {
        char *pos = (char *)memchr(GetReaderPos(), '\n', ReadAbleSize());
        return pos;
    }

    // 直接将一行的数据进行提取出来(包含 \n 位置)
    std::string GetLine()
    {
        char *pos = FindCRLF(); // 先找行末尾位置
        if (pos == nullptr)
        {
            return "";
        }

        return ReadAsString(pos - GetReaderPos() + 1);
    }

    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        ReadMoveOffset(str.size());
        return str;
    }

    // 清空buffer中的数据
    void Clear()
    {
        // 直接将偏移位置置0即可,表示下一次从0位置开始读取
        _writer_index = 0;
        _reader_index = 0;
    }
};

#define MAX_BACKLOG 128
class Socket
{
private:
    int _sockfd;

public:
    Socket() : _sockfd(-1){};
    Socket(int sockfd) : _sockfd(sockfd){};
    ~Socket() { Close(); };
    int Fd()
    {
        return _sockfd;
    }
    // 创建套接字
    bool Create()
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (_sockfd < 0)
        {
            ELOG("Create Socket Fail!");
            return false;
        }
        return true;
    }

    // 绑定IP和端口号
    bool Bind(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in local;
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = inet_addr(ip.c_str()); // inet_addr主机转网络再转uint32_t
        socklen_t len = sizeof(struct sockaddr_in);
        int ret = bind(_sockfd, (struct sockaddr *)&local, len);
        if (ret < 0)
        {
            ELOG("Bind Socket Fail!");
            return false;
        }
        return true;
    }

    // 设置监听状态   同一时刻的最大连接数
    bool Listen(int backlog = MAX_BACKLOG)
    {
        int ret = listen(_sockfd, backlog);
        if (ret < 0)
        {
            ELOG("Listen Socket Fail!");
            return false;
        }
        return true;
    }

    // 向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in local;
        local.sin_family = AF_INET;
        local.sin_port = htons(port);
        local.sin_addr.s_addr = inet_addr(ip.c_str()); // inet_addr主机转网络再转uint32_t
        socklen_t len = sizeof(struct sockaddr_in);
        int ret = connect(_sockfd, (struct sockaddr *)&local, len);
        if (ret < 0)
        {
            ELOG("Connect Socket Fail!");
            return false;
        }
        return true;
    }

    // 获取新连接  直接返回新的fd
    int Accept()
    {
        int newfd = accept(_sockfd, NULL, NULL);
        if (newfd < 0)
        {
            ELOG("Accept Newfd Fail!");
            return -1;
        }
        return newfd;
    }

    // 接送数据  默认为阻塞(可设置为非阻塞)
    ssize_t Recv(char *buf, size_t len, int flag = 0)
    {
        ssize_t ret = recv(_sockfd, buf, len, flag);
        if (ret <= 0)
        {
            // 如果是非阻塞,没有数据到来的状态下会收到 EAGAIN 错误码
            // 在阻塞状态下会被信号中断收到 EINTR 错误码
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0; // 不算接收数据错误,可重新获取数据
            }
            ELOG("Recv Data Fail!");
            return -1;
        }
        return ret; // 返回实际接收的大小
    }

    // 将发送设置为非阻塞
    ssize_t NonBlockRecv(char *buf, size_t len)
    {
        return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT表示当前接收为非阻塞
    }

    // 发送数据
    ssize_t Send(const char *buf, size_t len, int flag = 0)
    {
        ssize_t ret = send(_sockfd, buf, len, flag);
        if (ret <= 0)
        {
            // 如果是非阻塞,没有数据到来的状态下会收到 EAGAIN 错误码
            // 在阻塞状态下会被信号中断收到 EINTR 错误码
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0; // 不算发送数据错误,可重新发送数据
            }
            ELOG("Send Data Fail!");
            return -1;
        }
        return ret; // 返回实际发送的大小
    }

    ssize_t NonBlockSend(const char *buf, size_t len)
    {
        if (len == 0)
        {
            return 0;
        }
        return Send(buf, len, MSG_DONTWAIT); // 表示当前发送为非阻塞
    }

    // 关闭套接字
    bool Close()
    {
        if (_sockfd != -1)
        {
            close(_sockfd);
            _sockfd = -1;
        }
    }

    // 创建一个服务器连接  服务器绑定任意地址
    bool CreateServer(uint16_t port, const std::string &ip = "0.0.0.0", bool flag = false)
    {
        // 1、创建套接字   2、将文件描述符设置为非阻塞  3、绑定   4、设置监听状态  5、地址复用
        if (Create() == false)
            return false;
        ReuseAddress();
        if (flag)
            NonBlock();
        if (Bind(ip, port) == false)
            return false;
        if (Listen() == false)
            return false;
        return true;
    }

    // 创建一个客户端连接  客户端不需要绑定地址
    bool CreateClient(uint16_t port, const std::string &ip)
    {
        // 1、创建套接字   2、发起连接
        if (Create() == false)
            return false;
        if (Connect(ip, port) == false)
            return false;
        return true;
    }

    // 设置地址复用
    void ReuseAddress()
    {
        // setsockopt接口
        int opt = 1;
        setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, (void *)&opt, sizeof(opt));
    }

    // 将文件描述符设置为非阻塞
    void NonBlock()
    {
        // fcntl接口 先获取原有的属性，再添加新属性
        int fl = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, fl | O_NONBLOCK);
    }
};

class Epoller;
class EventLoop;
class Channel
{
    // EventLoop触发了什么事件，由Channel模块自己决定调用什么函数
private:
    int _fd; // 设置事件通过fd设置
    // EventLoop *_loop;
    Epoller *_epoller; // 实际的事件监控
    uint32_t _events;  // 当前需要关注的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallBack = std::function<void()>;
    EventCallBack _read_callback;  // 可读事件触发的回调处理
    EventCallBack _write_callback; // 可写事件触发的回调处理
    EventCallBack _err_callback;   // 错误事件触发的回调处理
    EventCallBack _close_callback; // 连接断开触发的回调处理
    EventCallBack _event_callback; // 任意事件触发的回调处理
public:
    // Channel(EventLoop *loop, int fd) : _fd(fd), _events(0), _revents(0), _loop(loop)
    // {
    // }

    Channel(Epoller *epoller, int fd)
        : _fd(fd), _events(0), _revents(0), _epoller(epoller)
    {
    }
    int Fd() { return _fd; }
    uint32_t GetEvents()
    {
        return _events;
    }
    void SetRevents(uint32_t events)
    {
        // EPollLoop模块监控到事件设置触发事件
        _revents = events;
    }
    // 回调函数都是通过connetion模块进行设置
    void SetReadCallBack(const EventCallBack &cb)
    {
        _read_callback = cb;
    }
    void SetWriteCallBack(const EventCallBack &cb)
    {
        _write_callback = cb;
    }
    void SetErrCallBack(const EventCallBack &cb)
    {
        _err_callback = cb;
    }
    void SetCloseCallBack(const EventCallBack &cb)
    {
        _close_callback = cb;
    }
    void SetEventCallBack(const EventCallBack &cb)
    {
        _event_callback = cb;
    }
    // 监控事件是否可读
    bool ReadAble()
    {
        return _events & EPOLLIN;
    }
    // 监控事件是否可写
    bool WriteAble()
    {
        return _events & EPOLLOUT;
    }
    // 启动读事件监控
    void EnableRead()
    {
        // 后面通过epollloop模块接口，添加到epoll模型中
        _events |= EPOLLIN;
        Update();
    }
    // 启动写事件监控
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }
    // 关闭读事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN; // 0010 &= 1101  -》 0000 关闭了
        Update();
    }
    // 关闭写事件监控
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }
    // 关闭所有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }
    // 新增或修改事件监控
    void Update();
    // 移除事件监控，从epoll的红黑树中移除 通过EventLoop接口实现
    void Remove();
    // 事件监控，触发什么事件，由自己决定怎么处理通过这个函数
    void HandleEvent()
    {
        // EPOLLRDHUP 表示对端关闭,当不会触发EPOLLERR 和 EPOLLHUP     EPOLLPRI 表示有紧急的带外数据
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            if (_event_callback)
            {
                _event_callback();
            }
            if (_read_callback)
            {
                _read_callback();
            }
        }
        /*有可能会造成连接断开，一次只处理一个*/
        if (_revents & EPOLLOUT)
        {
            if (_event_callback)
            {
                _event_callback();
            }
            if (_write_callback)
            {
                _write_callback();
            }
        }
        else if (_revents & EPOLLERR)
        {
            if (_event_callback)
            {
                _event_callback();
            }
            if (_err_callback)
            {
                _err_callback();
            }
        }
        else if (_revents & EPOLLHUP)
        {
            if (_event_callback)
            {
                _event_callback();
            }
            // EPOLLHUP  表示描述符的一端或两端已经关闭或挂断，或者被其他错误关闭。
            if (_close_callback)
            {
                _close_callback();
            }
        }
    }
};

#define MAX_EPOLLEVENT 1024
class Epoller
{
private:
    int _epollfd; // epoll模型句柄
    struct epoll_event _evt[MAX_EPOLLEVENT];
    // 存储fd与channel的映射关系  通过channel模块了解监控哪些事件 / 通过channel回调处理事件
    std::unordered_map<int, Channel *> _channels;

private:
    // 对epoll的直接操作  对channel模块里面的事件管理
    void Update(Channel *channel, int opt)
    {
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->GetEvents();
        int ret = epoll_ctl(_epollfd, opt, fd, &ev);
        if (ret < 0)
        {
            ELOG("EPOLL_CTL FAILED!");
        }
        return;
    }

    // 判断是否Channel添加了监控事件
    bool HasChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
        {
            return false;
        }
        return true;
    }

public:
    Epoller()
    {
        // 创建epoll模型
        _epollfd = epoll_create(MAX_EPOLLEVENT);
        if (_epollfd < 0)
        {
            ELOG("EPOLL_CREATE FAILED!");
            abort(); // 程序异常退出 收到了6号信号
        }
    }

    // 添加或修改监控事件
    void UpdateEvent(Channel *channel)
    {
        // 判断是否在管理中
        bool ret = HasChannel(channel);
        if (ret == false)
        {
            // 此时没有，需要新增
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }

    // 移除监控事件  管理中移除以及epoll中移除
    void DeleteEvent(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
        {
            _channels.erase(it);
        }
        return Update(channel, EPOLL_CTL_DEL);
    }

    // 开启监控事件，返回活跃连接  输出型参数
    void Epoll(std::vector<Channel *> *active)
    {
        int nfds = epoll_wait(_epollfd, _evt, MAX_EPOLLEVENT, -1); // 阻塞式监控  所有活跃的事件在evt中
        if (nfds < 0)
        {
            if (errno == EINTR)
            {
                // 被信号打断
                return;
            }
            ELOG("EPOLL_WAIT FAILED!");
            abort();
        }
        // 添加到vector中
        for (int i = 0; i < nfds; i++)
        {
            auto it = _channels.find(_evt[i].data.fd); // 一定是存在管理中的fd
            assert(it != _channels.end());
            it->second->SetRevents(_evt[i].events); // 将活跃事件添加到Revents中
            active->push_back(it->second);
        }
        return;
    }
};

// 新增或修改事件监控
void Channel::Update()
{
    // return _loop->UpdateEvent(this);
    return _epoller->UpdateEvent(this);
}

// 移除事件监控，从epoll的红黑树中移除 通过EventLoop接口实现
void Channel::Remove()
{
    // return _loop->RemoveEvent(this);
    return _epoller->DeleteEvent(this);
}

// // 定时任务的描述
// using TaskFunc = std::function<void()>;
// using TaskRelease = std::function<void()>;
// class TimeTask
// {
// private:
//     uint64_t _tid;        // 定时任务的id
//     bool _cancel;         // 取消定时任务
//     uint32_t _timeout;    // 定时任务的超时时间
//     TaskFunc _task_cb;    // 超时时要执行的任务
//     TaskRelease _release; // 用于删除uid与weak_ptr的映射关系

// public:
//     TimeTask(uint64_t id, uint32_t timeout, const TaskFunc &cb)
//         : _tid(id), _timeout(timeout), _task_cb(cb), _cancel(false)
//     {
//     }

//     ~TimeTask()
//     {
//         // 对象销毁时，执行定时任务
//         if (_cancel == false) // false代表任务没有被取消，true表示任务被取消
//         {
//             _task_cb();
//         }
//         _release();
//     }

//     void Cancel()
//     {
//         _cancel = true;
//     }

//     void SetRelease(const TaskRelease &cb)
//     {
//         _release = cb;
//     }

//     uint32_t GetTimeOut()
//     {
//         return _timeout;
//     }
// };

// // 时间轮执行定时任务
// using TaskPtr = std::shared_ptr<TimeTask>;
// using WeakPtr = std::weak_ptr<TimeTask>; // shared_ptr需要交给weak_ptr去维护
// class TimeWheel
// {
// private:
//     int _tick;                                    // 这个像指针，指向什么位置，任务超时被执行
//     int _capacity;                                // 表示时间轮的最大延迟时间
//     std::unordered_map<uint64_t, WeakPtr> _timer; // 存储的是任务id,和weak_ptr的映射
//     std::vector<std::vector<TaskPtr> > _wheel;    // 时间轮中存储的是任务的智能指针

//     EventLoop *_loop;                       // 通过eventloop模块来监控 _timerfd
//     int _timerfd;                           // 定时器描述符，可读事件回调就是读取次数，执行超时任务
//     std::unique_ptr<Channel> _time_channel; // 实际通过channel模块监控实现

// private:
//     void RemoveTimer(uint64_t id)
//     {
//         auto it = _timer.find(id);
//         if (it != _timer.end())
//         {
//             _timer.erase(id);
//         }
//     }

//     static int CreateTimerFd()
//     {
//         int timerfd = timerfd_create(CLOCK_MONOTONIC, 0); // CLOCK_MONOTONIC参数表示不受系统时间的限制，以系统启动时间为基准
//         if (timerfd < 0)
//         {
//             ELOG("TimerFd_Create Fail!");
//             abort();
//         }
//         // timerfd_settime(int fd, int flags, const struct itimerspec *new_value, struct itimerspec *old_value);
//         struct itimerspec itim;
//         itim.it_value.tv_sec = 1; // 设置第一次超时的时间
//         itim.it_value.tv_nsec = 0;
//         itim.it_interval.tv_sec = 1; // 第一次之后，每一次的超时时间
//         itim.it_interval.tv_nsec = 0;

//         timerfd_settime(timerfd, 0, &itim, NULL);
//         return timerfd;
//     }

//     int ReadTimeFd()
//     {
//         uint64_t res;
//         // 在读取时，有些文件描述符处理任务的时间比较久，有些定时器任务已经超时了
//         // read 读取出来的就是超时的定时器任务
//         int ret = read(_timerfd, &res, 8);
//         if (ret < 0)
//         {
//             ELOG("ReadTimeFd Fail!");
//             abort();
//         }

//         return res;
//     }

//     // _tick位置必须每秒走一步
//     void RunTaskTick()
//     {
//         _tick = (_tick + 1) % _capacity;
//         // 将数组中通过shared_ptr保存的任务进行释放
//         _wheel[_tick].clear();
//     }

//     // 根据实际超时的次数，执行超时任务
//     void OnTimer()
//     {
//         ReadTimeFd();
//         RunTaskTick();
//     }

//     // 添加定时任务
//     void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
//     {
//         TaskPtr pt(new TimeTask(id, delay, cb));
//         pt->SetRelease(std::bind(&TimeWheel::RemoveTimer, this, id));
//         int pos = (_tick + delay) % _capacity;
//         _wheel[pos].push_back(pt);
//         _timer[id] = WeakPtr(pt);
//     }

//     // 刷新 / 延长定时任务
//     void TimerRefresh(uint64_t id)
//     {
//         // 从id与weak_ptr的映射中获取到weak_ptr,再通过weak_ptr构造出shared_ptr对象
//         auto it = _timer.find(id);
//         if (it == _timer.end())
//         {
//             return;
//         }
//         TaskPtr pt = it->second.lock(); // lock就是从weak_ptr中获取shared_ptr对象
//         int delay = pt->GetTimeOut();
//         int pos = (_tick + delay) % _capacity;
//         _wheel[pos].push_back(pt);
//     }

//     void TimerCancel(uint64_t id)
//     {
//         auto it = _timer.find(id);
//         if (it == _timer.end())
//         {
//             return;
//         }

//         TaskPtr pt = it->second.lock();
//         if (pt)
//         {
//             pt->Cancel();
//         }
//     }

// public:
//     TimeWheel(EventLoop *loop)
//         : _tick(0), _capacity(60), _wheel(_capacity), _loop(loop),
//           _timerfd(CreateTimerFd()), _time_channel(new Channel(_loop, _timerfd))
//     {
//         // 将timerfd描述符设置可读事件
//         _time_channel->SetReadCallBack(std::bind(&TimeWheel::OnTimer, this));
//         // 启动可读事件
//         _time_channel->EnableRead();
//     }

//     // 因为timerfd成员，定时器任务可能会在多线程中执行，保证线程安全问题，要在同一线程中执行
//     void EventTimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb);

//     void EventTimerRefresh(uint64_t id);

//     void EventTimerCancel(uint64_t id);

//     // 判断是否存在这个定时器任务,存在线程安全问题，只能在EventLoop模块中使用
//     bool HasTimer(uint64_t id)
//     {
//         auto it = _timer.find(id);
//         if (it == _timer.end())
//         {
//             return false;
//         }
//         return true;
//     }
// };

// class EventLoop
// {
// private:
//     using Functor = std::function<void()>;
//     std::thread::id _thread_id;              // 线程id
//     int _eventfd;                            // 用于唤醒IO事件导致的阻塞事件
//     std::unique_ptr<Channel> _event_channel; // 对_eventfd的监控 使用智能指针进行管理，对象销毁，连接也跟着释放
//     Epoller _poller;                         // 对Epoller模块的监控
//     std::vector<Functor> _tasks;             // 任务队列,不在一个线程中，就压入任务队列
//     std::mutex _mutex;
//     TimeWheel _timer_wheel; // 定时器

// private:
//     // 运行任务队列中所有的任务
//     void RunAllTask()
//     {
//         std::vector<Functor> functor;
//         {
//             std::unique_lock<std::mutex> lock(_mutex);
//             _tasks.swap(functor);
//         }
//         for (auto &f : functor)
//         {
//             f();
//         }
//         return;
//     }

//     static int CreateEventFd()
//     {
//         int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
//         if (efd < 0)
//         {
//             ELOG("Create EventFd Fail!");
//             abort(); // 程序异常返回
//         }
//         return efd;
//     }

//     void ReadEventFd()
//     {
//         uint64_t res = 0;
//         ssize_t ret = read(_eventfd, &res, sizeof(res));
//         if (ret < 0)
//         {
//             if (errno == EINTR || errno == EAGAIN)
//             {
//                 return;
//             }
//             ELOG("ReadEventFd Fail!");
//             abort();
//         }
//         return;
//     }

//     void WeakUpEvent()
//     {
//         uint64_t val = 1;
//         ssize_t ret = write(_eventfd, &val, sizeof(val));
//         if (ret < 0)
//         {
//             if (errno == EINTR || errno == EAGAIN)
//             {
//                 return;
//             }
//             ELOG("WeakUpEvent Fail!");
//             abort();
//         }
//         return;
//     }

// public:
//     EventLoop()
//         : _thread_id(std::this_thread::get_id()),
//           _eventfd(CreateEventFd()),
//           _event_channel(new Channel(this, _eventfd)), _timer_wheel(this)
//     {
//         // 给eventfd设置可读事件回调，读取出可读次数
//         _event_channel->SetReadCallBack(std::bind(&EventLoop::ReadEventFd, this));
//         // 启动读事件
//         _event_channel->EnableRead();
//     };

//     // 启动EventLoop模块
//     void StartEventLoop()
//     {
//         while (1)
//         {
//             std::vector<Channel *> actives;
//             // 事件监控
//             _poller.Epoll(&actives);
//             // 处理就绪事件
//             for (auto &e : actives)
//             {
//                 e->HandleEvent();
//             }
//             // 执行任务
//             RunAllTask();
//         }
//     }
//     // 判断当前线程是否是EventLoop对应的线程
//     bool IsInLoop()
//     {
//         return (_thread_id == std::this_thread::get_id());
//     }

//     void AssertIsInLoop()
//     {
//         assert(_thread_id == std::this_thread::get_id());
//     }

//     // 用于判断当前要执行的任务是否处于一个线程中，如果是则执行，不是就压入任务队列中
//     void RunInLoop(const Functor &cb)
//     {
//         if (IsInLoop())
//         {
//             cb();
//             return;
//         }
//         return QueueInLoop(cb);
//     }

//     // 将任务压入队列中
//     void QueueInLoop(const Functor &cb)
//     {
//         {
//             std::unique_lock<std::mutex> lock(_mutex);
//             _tasks.push_back(cb);
//         }
//         // 唤醒因没有事件而阻塞的epoll，就是向eventfd中写入一次数据，进而唤醒事件
//         WeakUpEvent();
//     }

//     // 新增 / 修改 描述符的监控事件
//     void UpdateEvent(Channel *channel)
//     {
//         return _poller.UpdateEvent(channel);
//     }

//     // 移除描述符的监控
//     void RemoveEvent(Channel *channel)
//     {
//         return _poller.DeleteEvent(channel);
//     }

//     void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
//     {
//         return _timer_wheel.EventTimerAdd(id, delay, cb);
//     }

//     void TimerRefresh(uint64_t id)
//     {
//         return _timer_wheel.EventTimerRefresh(id);
//     }

//     void TimerCanel(uint64_t id)
//     {
//         return _timer_wheel.EventTimerCancel(id);
//     }

//     // 判断是否存在这个定时器任务
//     bool HasTimer(uint64_t id)
//     {
//         return _timer_wheel.HasTimer(id);
//     }
// };

// class LoopThread
// {
// private:
//     // 条件变量和互斥锁，用户实现loop的同步，避免线程创建了，没有实例化loop对象时，不能去获取loop对象
//     std::mutex _mutex;
//     std::condition_variable _cond; // 条件变量
//     EventLoop *_loop;              // EventLoop对应的指针，需要在线程内部进行实例化
//     std::thread _thread;           // EventLoop对应的线程
// private:
//     // 线程入口，实例化loop对象,唤醒条件变量下所有线程，并运行EventLoop模块
//     void ThreadEntry()
//     {
//         EventLoop loop; // 使得loop的生命周期随LoopThread模块
//         {
//             std::unique_lock<std::mutex> lock(_mutex);
//             _loop = &loop;
//             _cond.notify_all();
//         }
//         loop.StartEventLoop();
//     }

// public:
//     // 创建线程，并设置线程入口函数，一个eventloop与一个线程一一对应
//     LoopThread()
//         : _loop(NULL), _thread(std::bind(&LoopThread::ThreadEntry, this))
//     {
//     }

//     // 获取到EventLoop关联的指针
//     EventLoop *GetEventLoop()
//     {
//         // 如果还没有创建loop对象时，去条件变量下等待
//         EventLoop *loop = NULL;
//         {
//             std::unique_lock<std::mutex> lock(_mutex);
//             _cond.wait(lock, [&]()
//                        { return _loop != NULL; }); // 第二个参数是一个bool类型值
//             // 如果被唤醒，继续往下执行
//             loop = _loop;
//         }

//         return loop;
//     }
// };

// class LoopThreadPool
// {
// private:
//     int _slave_thread_number;           // 从属线程数量
//     int _next_index;                    // 下一个eventloop是谁
//     EventLoop *_baseloop;               // 主reactor，当从属线程数量为0时，所有的操作都在这里
//     std::vector<LoopThread *> _threads; // 用于保存所有的LoopThread
//     std::vector<EventLoop *> _loops;    // 当从属线程数量 > 0时，从loops中获取到eventloop进行分配，设置connection
// public:
//     LoopThreadPool(EventLoop *baseloop)
//         : _slave_thread_number(0), _next_index(0), _baseloop(baseloop)
//     {
//     }

//     // 设置所有的数量
//     void SetSlaveThreadNumber(int number)
//     {
//         _slave_thread_number = number;
//     }

//     // 创建从属线程
//     void CreateSlaveThreads()
//     {
//         if (_slave_thread_number > 0)
//         {
//             _threads.resize(_slave_thread_number);
//             _loops.resize(_slave_thread_number);

//             for (int i = 0; i < _slave_thread_number; i++)
//             {
//                 // 先创建线程
//                 _threads[i] = new LoopThread;
//                 _loops[i] = _threads[i]->GetEventLoop(); // 获取EventLoop指针，没有创建好线程，会阻塞
//             }
//         }

//         return;
//     }

//     // 获取到下一个EventLoop进行分配
//     EventLoop *GetNextEventLoop()
//     {
//         if (_slave_thread_number == 0)
//         {
//             return _baseloop;
//         }

//         _next_index = (_next_index + 1) % _slave_thread_number;
//         return _loops[_next_index];
//     }
// };

// // 设计一个存储任意报文（上下文）的通用容器
// class Any
// {
// private:
//     class holder
//     {
//     public:
//         virtual ~holder() {}
//         virtual const std::type_info &type() = 0;
//         virtual holder *clone() = 0;
//     };
//     template <class T>
//     class placeholder : public holder
//     {
//     public:
//         placeholder(const T &val)
//             : _val(val)
//         {
//         }
//         virtual const std::type_info &type() // 获取子类对象中存储的数据类型
//         {
//             return typeid(T);
//         }
//         virtual holder *clone() // 针对当前对象本身，克隆出一个新的子类对象
//         {
//             return new placeholder(_val); // 重新构造一份新的数据
//         }

//     public:
//         T _val;
//     };
//     holder *_content; // 通过多态调用子类的方法
// public:
//     Any &swap(Any &other)
//     {
//         std::swap(_content, other._content);
//         return *this;
//     }

// public:
//     Any() : _content(nullptr)
//     {
//     }

//     template <class T>
//     Any(const T &val) : _content(new placeholder<T>(val))
//     {
//     }

//     Any(const Any &other)
//         : _content(other._content ? other._content->clone() : nullptr)
//     {
//         // 不能使用other的指针
//     }

//     ~Any()
//     {
//         delete _content;
//     }

//     // 返回子类对象保存的数据指针 获取到保存的上下文内容
//     template <class T>
//     T *get()
//     {
//         assert(typeid(T) == _content->type());
//         return &((placeholder<T> *)_content)->_val; // 通过获取子类对象的指针获取值
//     }

//     // 重载=,其他容器进行赋值操作
//     template <class T>
//     Any &operator=(const T &val)
//     {
//         // 构造一个新的Any对象，进行swap之后，这个临时对象释放时，原来的数据也随着释放
//         Any(val).swap(*this);
//         return *this;
//     }

//     Any &operator=(const Any &other)
//     {
//         Any(other).swap(*this);
//         return *this;
//     }
// };

// // DISCONNECTED 连接已经关闭   CONNECTING 连接建立成功，等待处理 - 过度状态
// // CONNECTED 连接建立完成，可以通信   DISCONNECTING 连接处于一个等待关闭的状态
// typedef enum
// {
//     DISCONNECTED,
//     CONNECTING,
//     CONNECTED,
//     DISCONNECTING
// } ConneState;

// class Connection;
// using PtrConnect = std::shared_ptr<Connection>; // 使用智能指针进行管理，避免多线程进行释放操作

// class Connection : public std::enable_shared_from_this<Connection>
// {
// private:
//     uint64_t _con_id; // con连接的唯一id
//     // uint64_t _timerid   定时器的唯一id 可以使用con_id来代替
//     int _sockfd;                   // 连接关联的描述符
//     bool _enable_inactive_release; // 是否启动非活跃连接销毁的标志位  默认为false
//     Socket _socket;                // 对fd的管理
//     EventLoop *_loop;              // 连接所关联的eventloop
//     Channel _channel;              // 连接事件的管理
//     Buffer _in_buffer;             // 输入缓冲区 存储对端发送的数据
//     Buffer _out_buffer;            // 输出缓冲区 存储要发送给对端的数据
//     Any _context;                  // 请求接收的上下文
//     ConneState _constate;          // 连接的状态
//     // 回调函数处理，提供给使用者使用，由使用者设置功能，但是由服务器进行处理
//     using ConnectedCallBack = std::function<void(const PtrConnect &)>;
//     using MessageCallBack = std::function<void(const PtrConnect &, Buffer *)>;
//     using CloseCallBack = std::function<void(const PtrConnect &)>;
//     using AnyEventCallBack = std::function<void(const PtrConnect &)>;

//     ConnectedCallBack _connect_callback;
//     MessageCallBack _mess_callback;
//     CloseCallBack _close_callback;
//     AnyEventCallBack _any_callback;

//     /*组件内部的连接关闭回调，服务器组件内会把所有的连接进行管理起来，当某个连接释放时，就该移除掉对应的信息*/
//     CloseCallBack _server_close_callback;

// private:
//     /*五个channel的事件回调函数*/
//     /*描述符可读事件触发后的回调，通过socket接收到输入缓冲区当中，并调用 _mess_callback*/
//     void HandleRead()
//     {
//         char buffer[65536];
//         // 设置为非阻塞接收
//         ssize_t ret = _socket.NonBlockRecv(buffer, 65535);
//         if (ret < 0)
//         {
//             // 读取出错，但是不直接关闭连接，需要判断是否缓冲区中还有数据
//             return ShutdownInLoop();
//         }
//         // 并向后偏移
//         _in_buffer.WriterAndPush(buffer, ret);
//         if (_in_buffer.ReadAbleSize() > 0)
//         {
//             // shared_from_this 从当前对象自身中获取到shared_ptr管理的对象
//             return _mess_callback(shared_from_this(), &_in_buffer);
//         }
//     }

//     /*描述符可写事件触发的回调，将输出缓冲区的数据进行发送*/
//     void HandleWrite()
//     {
//         ssize_t ret = _socket.NonBlockSend(_out_buffer.GetReaderPos(), _out_buffer.ReadAbleSize());
//         if (ret < 0)
//         {
//             // 发送错误就该直接关闭连接 需要处理一下输入缓冲区的内容
//             if (_in_buffer.ReadAbleSize() > 0)
//             {
//                 // shared_from_this 从当前对象自身中获取到shared_ptr管理的对象
//                 _mess_callback(shared_from_this(), &_in_buffer);
//             }
//             return ReleaseInLoop();
//         }
//         // 将读偏移向后移动
//         _out_buffer.ReadMoveOffset(ret);
//         // 如果此时输出缓冲区中没有数据待发送，并处于一个待关闭状态，就直接关闭连接
//         if (_out_buffer.ReadAbleSize() == 0)
//         {
//             _channel.DisableWrite(); // 直接关闭写事件监控
//             if (_constate == DISCONNECTING)
//             {
//                 return ReleaseInLoop();
//             }
//         }
//         return; // 否则啥也不干，等待下一次的处理
//     }

//     /*描述符触发挂断事件*/
//     void HandleClose()
//     {
//         // 连接断开，套接字啥呀干不了，有数据就处理一下，直至关闭连接
//         if (_in_buffer.ReadAbleSize() > 0)
//         {
//             _mess_callback(shared_from_this(), &_in_buffer);
//         }
//         return ReleaseInLoop();
//     }

//     /*描述符触发错误事件*/
//     void HandleError()
//     {
//         return HandleClose();
//     }

//     /*描述符触发任意事件*/
//     void HandleEvent()
//     {
//         // 1、刷新一下活跃度 - 非活跃销毁任务开启时
//         if (_enable_inactive_release == true)
//         {
//             _loop->TimerRefresh(_con_id);
//         }
//         // 2、调用用户自己设置的任意事件回调
//         if (_any_callback)
//         {
//             _any_callback(shared_from_this());
//         }
//     }
//     // 下面的函数都是在loop线程内部执行
//     /*连接获取之后，所处的状态的各种设置（启动读监控，调用回调函数）*/
//     void EstablishInLoop()
//     {
//         // 1、修该连接状态
//         assert(_constate == CONNECTING); // 当前连接状态必须是上层的半连接状态
//         _constate = CONNECTED;
//         // 2、启动读监控
//         // 一旦启动读监控就有可能立即触发读事件，如果此时设置了非活跃销毁，会找不到定时任务
//         _channel.EnableRead();
//         // 3、调用回调函数
//         if (_connect_callback)
//         {
//             _connect_callback(shared_from_this());
//         }
//     }

//     /*这个接口并不是实际的发送接口，而是把数据放入输出缓冲区中，开启写事件监控*/
//     void SendConInLoop(Buffer buffer)
//     {
//         if (_constate == DISCONNECTED)
//             return;
//         _out_buffer.WriteBufferAndPush(buffer);
//         if (_channel.WriteAble() == false)
//         {
//             _channel.EnableWrite();
//         }
//     }

//     /*这个接口不是真正的连接关闭接口，还需要判断是否有数据需要处理，待发送*/
//     void ShutdownInLoop()
//     {
//         _constate = DISCONNECTING; // 连接置于一个半关闭状态
//         if (_in_buffer.ReadAbleSize() > 0)
//         {
//             if (_mess_callback)
//                 _mess_callback(shared_from_this(), &_in_buffer);
//         }

//         // 要么就是写入数据时出错，没有数据，直接关闭连接
//         if (_out_buffer.ReadAbleSize() > 0)
//         {
//             // 启动写事件监控  判断是否可写
//             if (_channel.WriteAble() == false)
//                 _channel.EnableWrite();
//         }
//         if (_out_buffer.ReadAbleSize() == 0)
//         {
//             ReleaseInLoop();
//         }
//     }

//     // 这个接口是实际关闭连接的接口
//     void ReleaseInLoop()
//     {
//         // 1、修改连接状态 置于关闭状态
//         _constate = DISCONNECTED;
//         // 2、移除事件监控
//         _channel.Remove();
//         // 3、关闭套接字
//         _socket.Close();
//         // 4、判断定时器任务队列中是否还有任务，有就取消任务
//         if (_loop->HasTimer(_con_id))
//         {
//             CancelInactiveReleaseInLoop();
//         }
//         // 5、调用连接关闭的回调函数 先调用用户的关闭回调，避免先调用服务器的关闭回调导致Connection释放
//         if (_close_callback)
//             _close_callback(shared_from_this());
//         /*移除服务器内部关闭的连接信息*/
//         if (_server_close_callback)
//             _server_close_callback(shared_from_this());
//     }

//     // 启动非活跃连接超时释放规则
//     void EnableInactiveReleaseInLoop(int sec)
//     {
//         // 1、将判断标志 _enable_inactive_release 置为true
//         _enable_inactive_release = true;
//         // 2、判断是否添加了定时销毁任务，如果有就刷新延迟一下
//         if (_loop->HasTimer(_con_id))
//         {
//             return _loop->TimerRefresh(_con_id);
//         }
//         // 3、没有就新增定时销毁任务
//         _loop->TimerAdd(_con_id, sec, std::bind(&Connection::ReleaseInLoop, this));
//     }

//     // 取消非活跃连接超时释放规则
//     void CancelInactiveReleaseInLoop()
//     {
//         _enable_inactive_release = false; // 是否刷新活跃度看这个标志位
//         if (_loop->HasTimer(_con_id))
//         {
//             _loop->TimerCanel(_con_id);
//         }
//     }

//     void UpgradeInLoop(const Any &context,
//                        const ConnectedCallBack &con,
//                        const MessageCallBack &msg,
//                        const CloseCallBack &closed,
//                        const AnyEventCallBack &event)
//     {
//         _context = context;
//         _connect_callback = con;
//         _mess_callback = msg;
//         _close_callback = closed;
//         _any_callback = event;
//     }

// public:
//     Connection(EventLoop *loop, int sockfd, int con_id)
//         : _con_id(con_id), _sockfd(sockfd), _loop(loop),
//           _enable_inactive_release(false), _socket(_sockfd),
//           _constate(CONNECTING), _channel(_loop, _sockfd)
//     {
//         // 设置channel的回调函数
//         _channel.SetReadCallBack(std::bind(&Connection::HandleRead, this));
//         _channel.SetWriteCallBack(std::bind(&Connection::HandleWrite, this));
//         _channel.SetCloseCallBack(std::bind(&Connection::HandleClose, this));
//         _channel.SetEventCallBack(std::bind(&Connection::HandleEvent, this));
//         _channel.SetErrCallBack(std::bind(&Connection::HandleError, this));
//     }
//     ~Connection()
//     {
//         DLOG("~ Connection:%p", this);
//     }
//     // 获取管理的文件描述符
//     int Fd()
//     {
//         return _sockfd;
//     }

//     // 获取连接ID
//     int ID()
//     {
//         return _con_id;
//     }

//     // 是否处于CONNECTED 连接建立完成
//     bool IsConnected()
//     {
//         return (_constate == CONNECTED);
//     }

//     // 设置上下文 - 连接建立完成时设置
//     void SetContext(const Any &context)
//     {
//         _context = context;
//     }

//     // 获取上下文 - 返回指针
//     Any *GetContext()
//     {
//         return &_context;
//     }

//     // 设置回调函数 使用者调用的
//     void SetConnectCallBack(const ConnectedCallBack &cb) { _connect_callback = cb; }
//     void SetMessageCallBack(const MessageCallBack &cb) { _mess_callback = cb; }
//     void SetCloseCallBack(const CloseCallBack &cb) { _close_callback = cb; }
//     void SetEventCallBack(const AnyEventCallBack &cb) { _any_callback = cb; }
//     void SetServerCloseCallBack(const CloseCallBack &cb) { _server_close_callback = cb; }

//     // 连接建立完成后，对channel模块的设置，开启读监控，调用connect回调
//     void Establish()
//     {
//         _loop->RunInLoop(std::bind(&Connection::EstablishInLoop, this));
//     }

//     void Release()
//     {
//         _loop->RunInLoop(std::bind(&Connection::ReleaseInLoop, this));
//     }

//     // 发送数据，将数据发送到输出缓冲区，并启动写事件监控
//     void SendCon(const char *buf, size_t len)
//     {
//         // 外面传入的buf，可能是一个临时空间，只是把发送的数据压入到了任务栈中，没有立即被执行，
//         // 此时的buf，可能已经被销毁了
//         Buffer buffer;
//         buffer.WriterAndPush(buf, len);
//         _loop->RunInLoop(std::bind(&Connection::SendConInLoop, this, buffer));
//     }

//     // 连接关闭 但不是实际的直接关闭连接 需要判断缓冲区中是否还有数据
//     void Shutdown()
//     {
//         _loop->RunInLoop(std::bind(&Connection::ShutdownInLoop, this));
//     }

//     // 启动非活跃的销毁任务，时间为sec 添加定时任务
//     void EnableInactiveRelease(int sec)
//     {
//         _loop->RunInLoop(std::bind(&Connection::EnableInactiveReleaseInLoop, this, sec));
//     }

//     // 取消非活跃的销毁任务
//     void CancelInactiveRelease()
//     {
//         _loop->RunInLoop(std::bind(&Connection::CancelInactiveReleaseInLoop, this));
//     }
//     // 协议切换 - 重置上下文已经阶段性的回调函数
//     void Upgrade(const Any &context, const ConnectedCallBack &con, const MessageCallBack &msg,
//                  const CloseCallBack &closed, const AnyEventCallBack &event)
//     {
//         // 要保证在一个线程中，不是一个线程不允许操作
//         _loop->AssertIsInLoop();
//         _loop->RunInLoop(std::bind(&Connection::UpgradeInLoop, this, context, con, msg, closed, event));
//     }
// };

// class Acceptor
// {
// private:
//     Socket _socket;   // 用于创建监听套接字
//     EventLoop *_loop; // 用于对监听套接字的监控
//     Channel _channel; // 用于对监听套接字的事件管理

//     using AcceptCallBack = std::function<void(int)>;
//     AcceptCallBack _accept_callback;

// private:
//     // 对监听套接字读事件的回调，获取新连接，并调用acceptcallback回调函数
//     void HandleRead()
//     {
//         int newfd = _socket.Accept();
//         if (newfd < 0)
//         {
//             return;
//         }
//         if (_accept_callback)
//         {
//             _accept_callback(newfd);
//         }
//     }

//     // 监听套接字的创建
//     int CreateServer(int port)
//     {
//         bool ret = _socket.CreateServer(port);
//         assert(ret == true);
//         return _socket.Fd();
//     }

// public:
//     /*启动事件监控，不能放在构造中，导致一启动，就会有连接到来，此时回调函数，还没有设置，导致资源泄露*/
//     Acceptor(EventLoop *loop, int port)
//         : _loop(loop), _socket(CreateServer(port)), _channel(_loop, _socket.Fd())
//     {
//         // 设置读回调函数
//         _channel.SetReadCallBack(std::bind(&Acceptor::HandleRead, this));
//     }

//     void Listen()
//     {
//         _channel.EnableRead(); // 启动可读事件
//     }

//     void SetAcceptCallBack(const AcceptCallBack &cb)
//     {
//         _accept_callback = cb;
//     }
// };

// class TcpServer
// {
// private:
//     int _port;
//     int _timeout;                                    // 非活跃连接超时销毁时间，如果超过这个时间就销毁
//     bool _enable_inactive_release;                   // 是否销毁的标记位
//     uint64_t _next_id;                               // 自动增长的连接ID
//     EventLoop _baseloop;                             // 主线程的loop对象，负责监听事件的处理
//     Acceptor _acceptor;                              // 监听套接字管理的对象
//     LoopThreadPool _loops;                           // 从属线程的线程池
//     std::unordered_map<uint64_t, PtrConnect> _conns; // 将所有的连接管理起来

//     using ConnectedCallBack = std::function<void(const PtrConnect &)>;
//     using MessageCallBack = std::function<void(const PtrConnect &, Buffer *)>;
//     using CloseCallBack = std::function<void(const PtrConnect &)>;
//     using AnyEventCallBack = std::function<void(const PtrConnect &)>;

//     using Functor = std::function<void()>;
//     ConnectedCallBack _connect_callback;
//     MessageCallBack _mess_callback;
//     CloseCallBack _close_callback;
//     AnyEventCallBack _any_callback;

// private:
//     void RunAfterInLoop(const Functor &cb, int delay)
//     {
//         _next_id++;
//         _baseloop.TimerAdd(_next_id, delay, cb);
//     }

//     // 为新连接构建一个Connection对象进行管理
//     void NewConnection(int fd)
//     {
//         _next_id++;
//         PtrConnect con(new Connection(_loops.GetNextEventLoop(), fd, _next_id));
//         con->SetConnectCallBack(_connect_callback); // 回调函数已经设置了，直接设置回调即可
//         con->SetMessageCallBack(_mess_callback);
//         con->SetEventCallBack(_any_callback);
//         con->SetCloseCallBack(_close_callback);
//         con->SetServerCloseCallBack(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
//         if (_enable_inactive_release == true)
//         {
//             con->EnableInactiveRelease(_timeout); // 启动非活跃连接销毁
//         }
//         con->Establish(); // 就绪初始化
//         _conns.insert(std::make_pair(_next_id, con));
//     }

//     void RemoveConnectionInLoop(const PtrConnect &conn)
//     {
//         auto it = _conns.find(conn->ID());
//         if (it != _conns.end())
//         {
//             _conns.erase(it);
//         }
//     }

//     // 从连接管理模块中移除管理
//     void RemoveConnection(const PtrConnect &conn)
//     {
//         _baseloop.RunInLoop(std::bind(&TcpServer::RemoveConnectionInLoop, this, conn));
//     }

// public:
//     TcpServer(int port)
//         : _port(port),
//           _next_id(0),
//           _enable_inactive_release(false),
//           _acceptor(&_baseloop, _port),
//           _loops(&_baseloop)
//     {
//         // 为监听套接字设置读回调
//         _acceptor.SetAcceptCallBack(std::bind(&TcpServer::NewConnection, this, std::placeholders::_1)); // handleread触发，调用accept回调函数
//         _acceptor.Listen();                                                                             // 启动可读事件
//     }

//     // 设置回调函数(连接，消息，关闭，任意) 设置为Connection模块
//     void SetConnectCallBack(const ConnectedCallBack &cb) { _connect_callback = cb; }
//     void SetMessageCallBack(const MessageCallBack &cb) { _mess_callback = cb; }
//     void SetCloseCallBack(const CloseCallBack &cb) { _close_callback = cb; }
//     void SetEventCallBack(const AnyEventCallBack &cb) { _any_callback = cb; }

//     // 设置线程数据
//     void SetThreadCount(int number)
//     {
//         return _loops.SetSlaveThreadNumber(number);
//     }

//     void EnableInactiveRelease(int timeout)
//     {
//         _timeout = timeout;
//         _enable_inactive_release = true;
//     }

//     // 用于添加一个定时任务  在线程内部进行添加
//     void RunAfter(const Functor &cb, int delay)
//     {
//         return _baseloop.RunInLoop(std::bind(&TcpServer::RunAfterInLoop, this, cb, delay));
//     }

//     void Start()
//     {
//         _loops.CreateSlaveThreads(); // 创建从属线程 不能放在构造函数里面，构造默认是0的
//         _baseloop.StartEventLoop();  // 开始运行，主eventloop模块
//     }
// };

// void TimeWheel::EventTimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb)
// {
//     _loop->RunInLoop(std::bind(&TimeWheel::TimerAdd, this, id, delay, cb));
// }

// void TimeWheel::EventTimerRefresh(uint64_t id)
// {
//     _loop->RunInLoop(std::bind(&TimeWheel::TimerRefresh, this, id));
// }

// void TimeWheel::EventTimerCancel(uint64_t id)
// {
//     _loop->RunInLoop(std::bind(&TimeWheel::TimerCancel, this, id));
// }

// class NetWork
// {
// public:
//     NetWork()
//     {
//         DLOG("SIGPIPE INIT!");
//         // 对主动断开连接的一方，当对端再次发送数据时，系统会给对端发送一个SIGPIPE的信号，中断进程的继续
//         signal(SIGPIPE, SIG_IGN);
//     }
// };

// static NetWork net;
